/**
 * 统一的未读消息计算工具函数
 * 用于在 RecentChatList、FriendsList、GroupsList 中统一计算未读消息数
 */

import type { Message } from '../stores/chat-types'

/**
 * 获取当前用户的所有可能ID（用于排除自己发送的消息）
 */
function getCurrentUserIds(): Set<string> {
  const ids = new Set<string>()
  
  try {
    // 从 chatStore 获取 currentUserId（这是最准确的）
    // 注意：这个函数可能在组件外部调用，所以不能直接访问 chatStore
    // 需要从 localStorage 或其他地方获取
    
    const currentUserId = localStorage.getItem('currentUserId')
    if (currentUserId) {
      ids.add(currentUserId)
    }
    
    const userStr = localStorage.getItem('user') || '{}'
    const user = JSON.parse(userStr)
    if (user.open_id) ids.add(user.open_id)
    if (user.name) ids.add(user.name)
    if (user.snowflake_id) ids.add(String(user.snowflake_id))
    if (user.id) ids.add(String(user.id))
    
    const openId = localStorage.getItem('openId')
    if (openId) ids.add(openId)
  } catch (e) {
    // 解析失败，忽略
  }
  
  return ids
}

/**
 * 检查消息是否来自当前用户
 */
function isMessageFromCurrentUser(msg: Message, currentUserIds: Set<string>): boolean {
  const msgFromId = String(msg.from_user_id || '').trim()
  
  // 检查所有可能的ID格式
  for (const userId of currentUserIds) {
    if (msgFromId === String(userId).trim()) {
      return true
    }
  }
  
  return false
}

/**
 * 获取当前用户的所有可能ID（用于单聊匹配）
 */
function getCurrentUserIdsForMatching(): Set<string> {
  const ids = new Set<string>()
  
  try {
    const currentUserId = localStorage.getItem('currentUserId')
    if (currentUserId) {
      ids.add(currentUserId)
    }
    
    const userStr = localStorage.getItem('user') || '{}'
    const user = JSON.parse(userStr)
    if (user.open_id) ids.add(user.open_id)
    if (user.name) ids.add(user.name)
    if (user.snowflake_id) ids.add(String(user.snowflake_id))
    if (user.id) ids.add(String(user.id))
    
    const openId = localStorage.getItem('openId')
    if (openId) ids.add(openId)
  } catch (e) {
    // 解析失败，忽略
  }
  
  return ids
}

/**
 * 检查消息是否匹配目标（单聊或群聊）
 * 对于单聊，需要确保消息是来自目标用户或发送给目标用户的
 */
function isMessageMatchTarget(
  msg: Message,
  targetId: string,
  chatType: number
): boolean {
  if (msg.chat_type !== chatType) {
    return false
  }
  
  if (chatType === 2) {
    // 群聊：检查 to_user_id 是否匹配
    const msgGroupId = String(msg.to_user_id || '').replace(/^group_/i, '').trim()
    const targetGroupId = String(targetId).replace(/^group_/i, '').trim()
    return msgGroupId === targetGroupId
  } else {
    // 单聊：需要更精确的匹配
    // 对于接收的消息（isReceived = true）：from_user_id 应该是目标用户，to_user_id 应该是当前用户
    // 对于发送的消息（isReceived = false）：from_user_id 应该是当前用户，to_user_id 应该是目标用户
    const msgFromId = String(msg.from_user_id || '').trim()
    const msgToId = String(msg.to_user_id || '').trim()
    const targetIdStr = String(targetId).trim()
    const currentUserIds = getCurrentUserIdsForMatching()
    
    // 检查 from_user_id 或 to_user_id 是否匹配目标用户
    const isFromTarget = msgFromId === targetIdStr
    const isToTarget = msgToId === targetIdStr
    
    // 检查 from_user_id 或 to_user_id 是否匹配当前用户
    const isFromCurrentUser = Array.from(currentUserIds).some(id => msgFromId === String(id).trim())
    const isToCurrentUser = Array.from(currentUserIds).some(id => msgToId === String(id).trim())
    
    // 单聊消息匹配：要么是接收的消息（from_target && to_current），要么是发送的消息（from_current && to_target）
    return (isFromTarget && isToCurrentUser) || (isFromCurrentUser && isToTarget)
  }
}

/**
 * 检查单聊消息是否来自好友（用于好友列表）
 */
function isSingleChatMessageFromFriend(
  msg: Message,
  friendId: string,
  friendOpenId?: string,
  friendName?: string,
  currentUserId?: string,
  currentOpenId?: string
): boolean {
  if (msg.chat_type !== 1) return false
  
  const msgFromId = String(msg.from_user_id || '').trim()
  const msgToId = String(msg.to_user_id || '').trim()
  const friendIdStr = String(friendId || '').trim()
  
  // 检查是否是好友发送给当前用户的消息
  const isFromFriend = msgFromId === friendIdStr || 
                      msgFromId === (friendOpenId || '') ||
                      msgFromId === (friendName || '')
  const isToCurrentUser = msgToId === (currentUserId || '') || 
                         msgToId === (currentOpenId || '')
  
  return isFromFriend && isToCurrentUser
}

// 缓存已警告的ID，避免重复输出日志
const warnedTargetIds = new Set<string>()

/**
 * 获取目标用户的所有可能ID（用于单聊匹配）
 * 从好友列表中查找所有可能的ID（open_id、name、to_id、snowflake_id等）
 */
function getTargetUserIds(targetId: string): Set<string> {
  const ids = new Set<string>()
  ids.add(targetId.trim())
  
  // 尝试从好友列表中查找所有可能的ID
  try {
    const friendsStr = localStorage.getItem('friends') || '[]'
    const friends = JSON.parse(friendsStr)
    
    const friend = friends.find((f: any) => {
      const friendData = f.user || f
      return friendData.open_id === targetId || 
             friendData.name === targetId || 
             f.to_id === targetId ||
             (friendData.snowflake_id && String(friendData.snowflake_id) === targetId) ||
             (friendData.id && String(friendData.id) === targetId)
    })
    
    if (friend) {
      const friendData = friend.user || friend
      if (friendData.open_id) ids.add(friendData.open_id)
      if (friendData.name) ids.add(friendData.name)
      if (friend.to_id) ids.add(friend.to_id)
      if (friendData.snowflake_id) ids.add(String(friendData.snowflake_id))
      if (friendData.id) ids.add(String(friendData.id))
      
      // 找到好友后，从警告缓存中移除（如果之前警告过）
      warnedTargetIds.delete(targetId)
    } else {
      // 只在第一次遇到这个ID时输出警告，避免重复日志
      // 并且只在开发环境且目标ID看起来像用户ID时才警告（排除群组ID等）
      const looksLikeUserId = !targetId.startsWith('group_') && 
                              !targetId.includes('_') && 
                              (targetId.length < 30 || /^[0-9a-f-]{36}$/i.test(targetId))
      
      if (import.meta.env.DEV && looksLikeUserId && !warnedTargetIds.has(targetId)) {
        warnedTargetIds.add(targetId)
        // 限制警告缓存大小，避免内存泄漏
        if (warnedTargetIds.size > 100) {
          const firstId = warnedTargetIds.values().next().value
          warnedTargetIds.delete(firstId)
        }
        console.log('⚠️ 未在好友列表中找到目标用户（仅首次警告）:', {
          targetId,
          friendsCount: friends.length,
          note: '这可能是正常的，如果这是群组ID或临时ID'
        })
      }
    }
  } catch (e) {
    // 解析失败，忽略（不输出日志，避免日志污染）
  }
  
  return ids
}

/**
 * 计算未读消息数（通用函数）
 */
export function calculateUnreadCount(
  messages: Message[],
  targetId: string,
  chatType: number,
  readSequence?: number | null
): number {
  const currentUserIds = getCurrentUserIds()
  const currentUserIdsForMatching = getCurrentUserIdsForMatching()
  
  // 如果没有 read_sequence，说明服务器没有返回已读记录
  // 这通常意味着：
  // 1. 这是一个新的聊天（还没有已读记录）
  // 2. 或者服务器数据不一致
  // 为了保守处理，如果 read_sequence 为 null/undefined，我们认为没有未读消息
  // 因为如果真的有未读消息，服务器应该会设置 read_sequence（即使是 0）
  // 这样可以避免重复计算已读消息为未读
  if (readSequence === undefined || readSequence === null) {
    // 返回 0，表示没有未读消息
    // 如果真的有未读消息，服务器应该会返回 read_sequence（即使是 0）
    return 0
  }
  
  // 有 read_sequence，根据时间戳判断
  const unreadMessages = messages.filter(msg => {
    // 匹配聊天类型
    if (msg.chat_type !== chatType) {
      return false
    }
    
    // 只统计接收的消息
    if (!msg.isReceived) {
      return false
    }
    
    // 排除自己发送的消息（双重检查）
    if (isMessageFromCurrentUser(msg, currentUserIds)) {
      return false
    }
    
    // 额外检查：如果 from_user_id 是当前用户，直接排除（即使 isReceived 被错误设置为 true）
    const msgFromId = String(msg.from_user_id || '').trim()
    for (const userId of currentUserIds) {
      if (msgFromId === String(userId).trim()) {
        return false
      }
    }
    
    // 匹配目标（对于单聊，需要更精确的匹配）
    if (chatType === 2) {
      // 群聊：检查 to_user_id 是否匹配
      const msgGroupId = String(msg.to_user_id || '').replace(/^group_/i, '').trim()
      const targetGroupId = String(targetId).replace(/^group_/i, '').trim()
      if (msgGroupId !== targetGroupId) {
        return false
      }
    } else {
      // 单聊：确保消息是来自目标用户发送给当前用户的
      const msgFromId = String(msg.from_user_id || '').trim()
      const msgToId = String(msg.to_user_id || '').trim()
      
      // 获取目标用户的所有可能ID
      const targetUserIds = getTargetUserIds(targetId)
      
      // 检查 from_user_id 是否匹配目标用户的任何ID（发送方）
      const isFromTarget = Array.from(targetUserIds).some(id => 
        msgFromId === String(id).trim()
      )
      
      // 检查 to_user_id 是否匹配当前用户（接收方）
      const isToCurrentUser = Array.from(currentUserIdsForMatching).some(id => 
        msgToId === String(id).trim()
      )
      
      // 必须是目标用户发送给当前用户的消息
      if (!isFromTarget || !isToCurrentUser) {
        return false
      }
    }
    
    // 检查消息时间戳是否大于 read_sequence
    const msgTimestamp = msg.timestamp_ms || msg.timestamp
    if (readSequence === 0) {
      return true // readSequence 为 0 表示从未读过，所有消息都是未读
    }
    return msgTimestamp > readSequence
  })
  
  return unreadMessages.length
}

/**
 * 计算好友未读消息数（单聊专用，考虑单聊的特殊匹配逻辑）
 */
export function calculateFriendUnreadCount(
  messages: Message[],
  friend: {
    to_id?: string
    user?: {
      open_id?: string
      name?: string
    }
  },
  chat?: {
    read_sequence?: number | null
  }
): number {
  const currentUserId = localStorage.getItem('currentUserId') || ''
  const currentOpenId = localStorage.getItem('openId') || ''
  const friendId = friend.to_id || friend.user?.open_id || friend.user?.name
  
  if (!friendId) {
    return 0
  }
  
  const readSequence = chat?.read_sequence
  
  // 如果没有 read_sequence，说明服务器没有返回已读记录
  // 为了保守处理，如果 read_sequence 为 null/undefined，我们认为没有未读消息
  // 这样可以避免重复计算已读消息为未读
  if (readSequence === undefined || readSequence === null) {
    return 0
  }
  
  // 有 read_sequence，根据时间戳判断
  const unreadMessages = messages.filter(msg => {
    if (!isSingleChatMessageFromFriend(
      msg,
      friendId,
      friend.user?.open_id,
      friend.user?.name,
      currentUserId,
      currentOpenId
    )) {
      return false
    }
    
    // 只统计接收的消息
    if (!msg.isReceived) {
      return false
    }
    
    // 排除自己发送的消息（多重检查）
    const msgFromId = String(msg.from_user_id || '').trim()
    const currentUserIds = new Set<string>()
    if (currentUserId) currentUserIds.add(currentUserId)
    if (currentOpenId) currentUserIds.add(currentOpenId)
    try {
      const userStr = localStorage.getItem('user') || '{}'
      const user = JSON.parse(userStr)
      if (user.open_id) currentUserIds.add(user.open_id)
      if (user.name) currentUserIds.add(user.name)
      if (user.snowflake_id) currentUserIds.add(String(user.snowflake_id))
      if (user.id) currentUserIds.add(String(user.id))
    } catch (e) {
      // 解析失败，忽略
    }
    
    // 检查 from_user_id 是否是当前用户的任何ID
    for (const userId of currentUserIds) {
      if (msgFromId === String(userId).trim()) {
        return false
      }
    }
    
    // 检查消息时间戳是否大于 read_sequence
    const msgTimestamp = msg.timestamp_ms || msg.timestamp
    if (readSequence === 0) {
      return true // readSequence 为 0 表示从未读过，所有消息都是未读
    }
    return msgTimestamp > readSequence
  })
  
  return unreadMessages.length
}

/**
 * 检查是否有新消息（用于显示红点）
 */
export function hasNewMessages(
  messages: Message[],
  targetId: string,
  chatType: number,
  readSequence?: number | null
): boolean {
  const currentUserIds = getCurrentUserIds()
  const currentUserIdsForMatching = getCurrentUserIdsForMatching()
  
  // 如果没有 read_sequence，说明服务器没有返回已读记录
  // 为了保守处理，如果 read_sequence 为 null/undefined，我们认为没有新消息
  if (readSequence === undefined || readSequence === null) {
    return false
  }
  
  const effectiveReadSequence = readSequence
  
  return messages.some(msg => {
    // 匹配聊天类型
    if (msg.chat_type !== chatType) {
      return false
    }
    
    // 只检查接收的消息
    if (!msg.isReceived) {
      return false
    }
    
    // 排除自己发送的消息（双重检查）
    if (isMessageFromCurrentUser(msg, currentUserIds)) {
      return false
    }
    
    // 额外检查：如果 from_user_id 是当前用户，直接排除（即使 isReceived 被错误设置为 true）
    const msgFromId = String(msg.from_user_id || '').trim()
    for (const userId of currentUserIds) {
      if (msgFromId === String(userId).trim()) {
        return false
      }
    }
    
    // 匹配目标（对于单聊，需要更精确的匹配）
    if (chatType === 2) {
      // 群聊：检查 to_user_id 是否匹配
      const msgGroupId = String(msg.to_user_id || '').replace(/^group_/i, '').trim()
      const targetGroupId = String(targetId).replace(/^group_/i, '').trim()
      if (msgGroupId !== targetGroupId) {
        return false
      }
    } else {
      // 单聊：确保消息是来自目标用户发送给当前用户的
      const msgFromId = String(msg.from_user_id || '').trim()
      const msgToId = String(msg.to_user_id || '').trim()
      
      // 获取目标用户的所有可能ID
      const targetUserIds = getTargetUserIds(targetId)
      
      // 检查 from_user_id 是否匹配目标用户的任何ID（发送方）
      const isFromTarget = Array.from(targetUserIds).some(id => 
        msgFromId === String(id).trim()
      )
      
      // 检查 to_user_id 是否匹配当前用户（接收方）
      const isToCurrentUser = Array.from(currentUserIdsForMatching).some(id => 
        msgToId === String(id).trim()
      )
      
      // 必须是目标用户发送给当前用户的消息
      if (!isFromTarget || !isToCurrentUser) {
        return false
      }
    }
    
    // 检查消息时间戳是否大于 read_sequence
    const msgTimestamp = msg.timestamp_ms || msg.timestamp
    if (effectiveReadSequence === 0) {
      return true // readSequence 为 0 表示从未读过，所有消息都是未读
    }
    return msgTimestamp > effectiveReadSequence
  })
}

/**
 * 检查好友是否有新消息（单聊专用）
 */
export function hasFriendNewMessages(
  messages: Message[],
  friend: {
    to_id?: string
    user?: {
      open_id?: string
      name?: string
    }
  },
  chat?: {
    read_sequence?: number | null
    sequence?: number
  }
): boolean {
  const currentUserId = localStorage.getItem('currentUserId') || ''
  const currentOpenId = localStorage.getItem('openId') || ''
  const friendId = friend.to_id || friend.user?.open_id || friend.user?.name
  
  if (!friendId) {
    return false
  }
  
  const readSequence = chat?.read_sequence
  
  // 如果没有 read_sequence，说明服务器没有返回已读记录
  // 为了保守处理，如果 read_sequence 为 null/undefined，我们认为没有新消息
  if (readSequence === undefined || readSequence === null) {
    return false
  }
  
  const effectiveReadSequence = readSequence
  
  // 检查消息列表中是否有接收的未读消息
  const hasReceivedMessages = messages.some(msg => {
    if (!isSingleChatMessageFromFriend(
      msg,
      friendId,
      friend.user?.open_id,
      friend.user?.name,
      currentUserId,
      currentOpenId
    )) {
      return false
    }
    
    // 只检查接收的消息
    if (!msg.isReceived) {
      return false
    }
    
    // 排除自己发送的消息
    const msgFromId = String(msg.from_user_id || '').trim()
    if (msgFromId === currentUserId || msgFromId === currentOpenId) {
      return false
    }
    
    // 检查消息时间戳是否大于 read_sequence
    const msgTimestamp = msg.timestamp_ms || msg.timestamp
    if (effectiveReadSequence === 0) {
      return true
    }
    return msgTimestamp > effectiveReadSequence
  })
  
  // 如果消息列表中有接收的未读消息，显示红点
  if (hasReceivedMessages) {
    return true
  }
  
  // 如果服务器端显示有新消息（sequence > read_sequence），但消息列表中没有接收的消息
  // 说明有未读消息但可能还没加载到本地，也应该显示红点
  // 注意：只有当 read_sequence > 0 时才检查，避免 read_sequence 为 0 时误判
  if (chat?.sequence && chat.sequence > effectiveReadSequence && effectiveReadSequence > 0) {
    return true
  }
  
  return false
}

